Chartist.times = function(length) {
  return Array.apply(null, new Array(length));
};
  

    Chartist.sum = function(previous, current) {
  return previous + (current ? current : 0);
};
  

    Chartist.mapMultiply = function(factor) {
  return function(num) {
    return num * factor;
  };
};
  

    Chartist.mapAdd = function(addend) {
  return function(num) {
    return num + addend;
  };
};
  

    Chartist.serialMap = function(arr, cb) {
  var result = [],
      length = Math.max.apply(null, arr.map(function(e) {
        return e.length;
      }));

  Chartist.times(length).forEach(function(e, index) {
    var args = arr.map(function(e) {
      return e[index];
    });

    result[index] = cb.apply(null, args);
  });

  return result;
};
  

    Chartist.roundWithPrecision = function(value, digits) {
  var precision = Math.pow(10, digits || Chartist.precision);
  return Math.round(value * precision) / precision;
};
  

    Chartist.serialize = function(data) {
  if(data === null || data === undefined) {
    return data;
  } else if(typeof data === 'number') {
    data = ''+data;
  } else if(typeof data === 'object') {
    data = JSON.stringify({data: data});
  }

  return Object.keys(Chartist.escapingMap).reduce(function(result, key) {
    return Chartist.replaceAll(result, key, Chartist.escapingMap[key]);
  }, data);
};
  

    Chartist.deserialize = function(data) {
  if(typeof data !== 'string') {
    return data;
  }

  data = Object.keys(Chartist.escapingMap).reduce(function(result, key) {
    return Chartist.replaceAll(result, Chartist.escapingMap[key], key);
  }, data);

  try {
    data = JSON.parse(data);
    data = data.data !== undefined ? data.data : data;
  } catch(e) {}

  return data;
};
  

    Chartist.createSvg = function (container, width, height, className) {
  var svg;

  width = width || '100%';
  height = height || '100%';

  // Check if there is a previous SVG element in the container that contains the Chartist XML namespace and remove it
  // Since the DOM API does not support namespaces we need to manually search the returned list http://www.w3.org/TR/selectors-api/
  Array.prototype.slice.call(container.querySelectorAll('svg')).filter(function filterChartistSvgObjects(svg) {
    return svg.getAttributeNS(Chartist.namespaces.xmlns, 'ct');
  }).forEach(function removePreviousElement(svg) {
    container.removeChild(svg);
  });

  // Create svg object with width and height or use 100% as default
  svg = new Chartist.Svg('svg').attr({
    width: width,
    height: height
  }).addClass(className);

  svg._node.style.width = width;
  svg._node.style.height = height;

  // Add the DOM node to our container
  container.appendChild(svg._node);

  return svg;
};
  

    Chartist.reverseData = function(data) {
  data.labels.reverse();
  data.series.reverse();
  for (var i = 0; i < data.series.length; i++) {
    if(typeof(data.series[i]) === 'object' && data.series[i].data !== undefined) {
      data.series[i].data.reverse();
    } else if(data.series[i] instanceof Array) {
      data.series[i].reverse();
    }
  }
};
  

    Chartist.getDataArray = function(data, reverse, multi) {
  // Recursively walks through nested arrays and convert string values to numbers and objects with value properties
  // to values. Check the tests in data core -> data normalization for a detailed specification of expected values
  function recursiveConvert(value) {
    if(Chartist.safeHasProperty(value, 'value')) {
      // We are dealing with value object notation so we need to recurse on value property
      return recursiveConvert(value.value);
    } else if(Chartist.safeHasProperty(value, 'data')) {
      // We are dealing with series object notation so we need to recurse on data property
      return recursiveConvert(value.data);
    } else if(value instanceof Array) {
      // Data is of type array so we need to recurse on the series
      return value.map(recursiveConvert);
    } else if(Chartist.isDataHoleValue(value)) {
      // We're dealing with a hole in the data and therefore need to return undefined
      // We're also returning undefined for multi value output
      return undefined;
    } else {
      // We need to prepare multi value output (x and y data)
      if(multi) {
        var multiValue = {};

        // Single series value arrays are assumed to specify the Y-Axis value
        // For example: [1, 2] => [{x: undefined, y: 1}, {x: undefined, y: 2}]
        // If multi is a string then it's assumed that it specified which dimension should be filled as default
        if(typeof multi === 'string') {
          multiValue[multi] = Chartist.getNumberOrUndefined(value);
        } else {
          multiValue.y = Chartist.getNumberOrUndefined(value);
        }

        multiValue.x = value.hasOwnProperty('x') ? Chartist.getNumberOrUndefined(value.x) : multiValue.x;
        multiValue.y = value.hasOwnProperty('y') ? Chartist.getNumberOrUndefined(value.y) : multiValue.y;

        return multiValue;

      } else {
        // We can return simple data
        return Chartist.getNumberOrUndefined(value);
      }
    }
  }

  return data.series.map(recursiveConvert);
};
  

    Chartist.normalizePadding = function(padding, fallback) {
  fallback = fallback || 0;

  return typeof padding === 'number' ? {
    top: padding,
    right: padding,
    bottom: padding,
    left: padding
  } : {
    top: typeof padding.top === 'number' ? padding.top : fallback,
    right: typeof padding.right === 'number' ? padding.right : fallback,
    bottom: typeof padding.bottom === 'number' ? padding.bottom : fallback,
    left: typeof padding.left === 'number' ? padding.left : fallback
  };
};

Chartist.getMetaData = function(series, index) {
  var value = series.data ? series.data[index] : series[index];
  return value ? value.meta : undefined;
};
  

    Chartist.orderOfMagnitude = function (value) {
  return Math.floor(Math.log(Math.abs(value)) / Math.LN10);
};
  

    Chartist.projectLength = function (axisLength, length, bounds) {
  return length / bounds.range * axisLength;
};
  

    Chartist.getAvailableHeight = function (svg, options) {
  return Math.max((Chartist.quantity(options.height).value || svg.height()) - (options.chartPadding.top +  options.chartPadding.bottom) - options.axisX.offset, 0);
};
  

    Chartist.getHighLow = function (data, options, dimension) {
  // TODO: Remove workaround for deprecated global high / low config. Axis high / low configuration is preferred
  options = Chartist.extend({}, options, dimension ? options['axis' + dimension.toUpperCase()] : {});

  var highLow = {
      high: options.high === undefined ? -Number.MAX_VALUE : +options.high,
      low: options.low === undefined ? Number.MAX_VALUE : +options.low
    };
  var findHigh = options.high === undefined;
  var findLow = options.low === undefined;

  // Function to recursively walk through arrays and find highest and lowest number
  function recursiveHighLow(data) {
    if(data === undefined) {
      return undefined;
    } else if(data instanceof Array) {
      for (var i = 0; i < data.length; i++) {
        recursiveHighLow(data[i]);
      }
    } else {
      var value = dimension ? +data[dimension] : +data;

      if (findHigh && value > highLow.high) {
        highLow.high = value;
      }

      if (findLow && value < highLow.low) {
        highLow.low = value;
      }
    }
  }

  // Start to find highest and lowest number recursively
  if(findHigh || findLow) {
    recursiveHighLow(data);
  }

  // Overrides of high / low based on reference value, it will make sure that the invisible reference value is
  // used to generate the chart. This is useful when the chart always needs to contain the position of the
  // invisible reference value in the view i.e. for bipolar scales.
  if (options.referenceValue || options.referenceValue === 0) {
    highLow.high = Math.max(options.referenceValue, highLow.high);
    highLow.low = Math.min(options.referenceValue, highLow.low);
  }

  // If high and low are the same because of misconfiguration or flat data (only the same value) we need
  // to set the high or low to 0 depending on the polarity
  if (highLow.high <= highLow.low) {
    // If both values are 0 we set high to 1
    if (highLow.low === 0) {
      highLow.high = 1;
    } else if (highLow.low < 0) {
      // If we have the same negative value for the bounds we set bounds.high to 0
      highLow.high = 0;
    } else if (highLow.high > 0) {
      // If we have the same positive value for the bounds we set bounds.low to 0
      highLow.low = 0;
    } else {
      // If data array was empty, values are Number.MAX_VALUE and -Number.MAX_VALUE. Set bounds to prevent errors
      highLow.high = 1;
      highLow.low = 0;
    }
  }

  return highLow;
};
  

    Chartist.isNumeric = function(value) {
  return value === null ? false : isFinite(value);
};
  

    Chartist.isFalseyButZero = function(value) {
  return !value && value !== 0;
};
  

    Chartist.getNumberOrUndefined = function(value) {
  return Chartist.isNumeric(value) ? +value : undefined;
};
  

    Chartist.isMultiValue = function(value) {
  return typeof value === 'object' && ('x' in value || 'y' in value);
};
  

    Chartist.getMultiValue = function(value, dimension) {
  if(Chartist.isMultiValue(value)) {
    return Chartist.getNumberOrUndefined(value[dimension || 'y']);
  } else {
    return Chartist.getNumberOrUndefined(value);
  }
};
  

    Chartist.rho = function(num) {
  if(num === 1) {
    return num;
  }

  function gcd(p, q) {
    if (p % q === 0) {
      return q;
    } else {
      return gcd(q, p % q);
    }
  }

  function f(x) {
    return x * x + 1;
  }

  var x1 = 2, x2 = 2, divisor;
  if (num % 2 === 0) {
    return 2;
  }

  do {
    x1 = f(x1) % num;
    x2 = f(f(x2)) % num;
    divisor = gcd(Math.abs(x1 - x2), num);
  } while (divisor === 1);

  return divisor;
};
  

    Chartist.getBounds = function (axisLength, highLow, scaleMinSpace, onlyInteger) {
  var i,
    optimizationCounter = 0,
    newMin,
    newMax,
    bounds = {
      high: highLow.high,
      low: highLow.low
    };

  bounds.valueRange = bounds.high - bounds.low;
  bounds.oom = Chartist.orderOfMagnitude(bounds.valueRange);
  bounds.step = Math.pow(10, bounds.oom);
  bounds.min = Math.floor(bounds.low / bounds.step) * bounds.step;
  bounds.max = Math.ceil(bounds.high / bounds.step) * bounds.step;
  bounds.range = bounds.max - bounds.min;
  bounds.numberOfSteps = Math.round(bounds.range / bounds.step);

  // Optimize scale step by checking if subdivision is possible based on horizontalGridMinSpace
  // If we are already below the scaleMinSpace value we will scale up
  var length = Chartist.projectLength(axisLength, bounds.step, bounds);
  var scaleUp = length < scaleMinSpace;
  var smallestFactor = onlyInteger ? Chartist.rho(bounds.range) : 0;

  // First check if we should only use integer steps and if step 1 is still larger than scaleMinSpace so we can use 1
  if(onlyInteger && Chartist.projectLength(axisLength, 1, bounds) >= scaleMinSpace) {
    bounds.step = 1;
  } else if(onlyInteger && smallestFactor < bounds.step && Chartist.projectLength(axisLength, smallestFactor, bounds) >= scaleMinSpace) {
    // If step 1 was too small, we can try the smallest factor of range
    // If the smallest factor is smaller than the current bounds.step and the projected length of smallest factor
    // is larger than the scaleMinSpace we should go for it.
    bounds.step = smallestFactor;
  } else {
    // Trying to divide or multiply by 2 and find the best step value
    while (true) {
      if (scaleUp && Chartist.projectLength(axisLength, bounds.step, bounds) <= scaleMinSpace) {
        bounds.step *= 2;
      } else if (!scaleUp && Chartist.projectLength(axisLength, bounds.step / 2, bounds) >= scaleMinSpace) {
        bounds.step /= 2;
        if(onlyInteger && bounds.step % 1 !== 0) {
          bounds.step *= 2;
          break;
        }
      } else {
        break;
      }

      if(optimizationCounter++ > 1000) {
        throw new Error('Exceeded maximum number of iterations while optimizing scale step!');
      }
    }
  }

  var EPSILON = 2.221E-16;
  bounds.step = Math.max(bounds.step, EPSILON);
  function safeIncrement(value, increment) {
    // If increment is too small use *= (1+EPSILON) as a simple nextafter
    if (value === (value += increment)) {
    	value *= (1 + (increment > 0 ? EPSILON : -EPSILON));
    }
    return value;
  }

  // Narrow min and max based on new step
  newMin = bounds.min;
  newMax = bounds.max;
  while (newMin + bounds.step <= bounds.low) {
  	newMin = safeIncrement(newMin, bounds.step);
  }
  while (newMax - bounds.step >= bounds.high) {
  	newMax = safeIncrement(newMax, -bounds.step);
  }
  bounds.min = newMin;
  bounds.max = newMax;
  bounds.range = bounds.max - bounds.min;

  var values = [];
  for (i = bounds.min; i <= bounds.max; i = safeIncrement(i, bounds.step)) {
    var value = Chartist.roundWithPrecision(i);
    if (value !== values[values.length - 1]) {
      values.push(value);
    }
  }
  bounds.values = values;
  return bounds;
};
  

    Chartist.polarToCartesian = function (centerX, centerY, radius, angleInDegrees) {
  var angleInRadians = (angleInDegrees - 90) * Math.PI / 180.0;

  return {
    x: centerX + (radius * Math.cos(angleInRadians)),
    y: centerY + (radius * Math.sin(angleInRadians))
  };
};
  

    Chartist.createChartRect = function (svg, options, fallbackPadding) {
  var hasAxis = !!(options.axisX || options.axisY);
  var yAxisOffset = hasAxis ? options.axisY.offset : 0;
  var xAxisOffset = hasAxis ? options.axisX.offset : 0;
  // If width or height results in invalid value (including 0) we fallback to the unitless settings or even 0
  var width = svg.width() || Chartist.quantity(options.width).value || 0;
  var height = svg.height() || Chartist.quantity(options.height).value || 0;
  var normalizedPadding = Chartist.normalizePadding(options.chartPadding, fallbackPadding);

  // If settings were to small to cope with offset (legacy) and padding, we'll adjust
  width = Math.max(width, yAxisOffset + normalizedPadding.left + normalizedPadding.right);
  height = Math.max(height, xAxisOffset + normalizedPadding.top + normalizedPadding.bottom);

  var chartRect = {
    padding: normalizedPadding,
    width: function () {
      return this.x2 - this.x1;
    },
    height: function () {
      return this.y1 - this.y2;
    }
  };

  if(hasAxis) {
    if (options.axisX.position === 'start') {
      chartRect.y2 = normalizedPadding.top + xAxisOffset;
      chartRect.y1 = Math.max(height - normalizedPadding.bottom, chartRect.y2 + 1);
    } else {
      chartRect.y2 = normalizedPadding.top;
      chartRect.y1 = Math.max(height - normalizedPadding.bottom - xAxisOffset, chartRect.y2 + 1);
    }

    if (options.axisY.position === 'start') {
      chartRect.x1 = normalizedPadding.left + yAxisOffset;
      chartRect.x2 = Math.max(width - normalizedPadding.right, chartRect.x1 + 1);
    } else {
      chartRect.x1 = normalizedPadding.left;
      chartRect.x2 = Math.max(width - normalizedPadding.right - yAxisOffset, chartRect.x1 + 1);
    }
  } else {
    chartRect.x1 = normalizedPadding.left;
    chartRect.x2 = Math.max(width - normalizedPadding.right, chartRect.x1 + 1);
    chartRect.y2 = normalizedPadding.top;
    chartRect.y1 = Math.max(height - normalizedPadding.bottom, chartRect.y2 + 1);
  }

  return chartRect;
};
  

    Chartist.createGrid = function(position, index, axis, offset, length, group, classes, eventEmitter) {
  var positionalData = {};
  positionalData[axis.units.pos + '1'] = position;
  positionalData[axis.units.pos + '2'] = position;
  positionalData[axis.counterUnits.pos + '1'] = offset;
  positionalData[axis.counterUnits.pos + '2'] = offset + length;

  var gridElement = group.elem('line', positionalData, classes.join(' '));

  // Event for grid draw
  eventEmitter.emit('draw',
    Chartist.extend({
      type: 'grid',
      axis: axis,
      index: index,
      group: group,
      element: gridElement
    }, positionalData)
  );
};
  

    Chartist.createGridBackground = function (gridGroup, chartRect, className, eventEmitter) {
  var gridBackground = gridGroup.elem('rect', {
      x: chartRect.x1,
      y: chartRect.y2,
      width: chartRect.width(),
      height: chartRect.height(),
    }, className, true);

    // Event for grid background draw
    eventEmitter.emit('draw', {
      type: 'gridBackground',
      group: gridGroup,
      element: gridBackground
    });
};
  

    Chartist.createLabel = function(position, length, index, labels, axis, axisOffset, labelOffset, group, classes, useForeignObject, eventEmitter) {
  var labelElement;
  var positionalData = {};

  positionalData[axis.units.pos] = position + labelOffset[axis.units.pos];
  positionalData[axis.counterUnits.pos] = labelOffset[axis.counterUnits.pos];
  positionalData[axis.units.len] = length;
  positionalData[axis.counterUnits.len] = Math.max(0, axisOffset - 10);

  if(useForeignObject) {
    // We need to set width and height explicitly to px as span will not expand with width and height being
    // 100% in all browsers
    var content = document.createElement('span');
    content.className = classes.join(' ');
    content.setAttribute('xmlns', Chartist.namespaces.xhtml);
    content.innerText = labels[index];
    content.style[axis.units.len] = Math.round(positionalData[axis.units.len]) + 'px';
    content.style[axis.counterUnits.len] = Math.round(positionalData[axis.counterUnits.len]) + 'px';

    labelElement = group.foreignObject(content, Chartist.extend({
      style: 'overflow: visible;'
    }, positionalData));
  } else {
    labelElement = group.elem('text', positionalData, classes.join(' ')).text(labels[index]);
  }

  eventEmitter.emit('draw', Chartist.extend({
    type: 'label',
    axis: axis,
    index: index,
    group: group,
    element: labelElement,
    text: labels[index]
  }, positionalData));
};
  

    Chartist.optionsProvider = function (options, responsiveOptions, eventEmitter) {
  var baseOptions = Chartist.extend({}, options),
    currentOptions,
    mediaQueryListeners = [],
    i;

  function updateCurrentOptions(mediaEvent) {
    var previousOptions = currentOptions;
    currentOptions = Chartist.extend({}, baseOptions);

    if (responsiveOptions) {
      for (i = 0; i < responsiveOptions.length; i++) {
        var mql = window.matchMedia(responsiveOptions[i][0]);
        if (mql.matches) {
          currentOptions = Chartist.extend(currentOptions, responsiveOptions[i][1]);
        }
      }
    }

    if(eventEmitter && mediaEvent) {
      eventEmitter.emit('optionsChanged', {
        previousOptions: previousOptions,
        currentOptions: currentOptions
      });
    }
  }

  function removeMediaQueryListeners() {
    mediaQueryListeners.forEach(function(mql) {
      mql.removeListener(updateCurrentOptions);
    });
  }

  if (!window.matchMedia) {
    throw 'window.matchMedia not found! Make sure you\'re using a polyfill.';
  } else if (responsiveOptions) {

    for (i = 0; i < responsiveOptions.length; i++) {
      var mql = window.matchMedia(responsiveOptions[i][0]);
      mql.addListener(updateCurrentOptions);
      mediaQueryListeners.push(mql);
    }
  }
  // Execute initially without an event argument so we get the correct options
  updateCurrentOptions();

  return {
    removeMediaQueryListeners: removeMediaQueryListeners,
    getCurrentOptions: function getCurrentOptions() {
      return Chartist.extend({}, currentOptions);
    }
  };
};


/**
 * Splits a list of coordinates and associated values into segments. Each returned segment contains a pathCoordinates
 * valueData property describing the segment.
 *
 * With the default options, segments consist of contiguous sets of points that do not have an undefined value. Any
 * points with undefined values are discarded.
 *
 * **Options**
 * The following options are used to determine how segments are formed
 * ```javascript
 * var options = {
 *   // If fillHoles is true, undefined values are simply discarded without creating a new segment. Assuming other options are default, this returns single segment.
 *   fillHoles: false,
 *   // If increasingX is true, the coordinates in all segments have strictly increasing x-values.
 *   increasingX: false
 * };
 * ```
 *
 * @memberof Chartist.Core
 * @param {Array} pathCoordinates List of point coordinates to be split in the form [x1, y1, x2, y2 ... xn, yn]
 * @param {Array} values List of associated point values in the form [v1, v2 .. vn]
 * @param {Object} options Options set by user
 * @return {Array} List of segments, each containing a pathCoordinates and valueData property.
 */
Chartist.splitIntoSegments = function(pathCoordinates, valueData, options) {
  var defaultOptions = {
    increasingX: false,
    fillHoles: false
  };

  options = Chartist.extend({}, defaultOptions, options);

  var segments = [];
  var hole = true;

  for(var i = 0; i < pathCoordinates.length; i += 2) {
    // If this value is a "hole" we set the hole flag
    if(Chartist.getMultiValue(valueData[i / 2].value) === undefined) {
    // if(valueData[i / 2].value === undefined) {
      if(!options.fillHoles) {
        hole = true;
      }
    } else {
      if(options.increasingX && i >= 2 && pathCoordinates[i] <= pathCoordinates[i-2]) {
        // X is not increasing, so we need to make sure we start a new segment
        hole = true;
      }


      // If it's a valid value we need to check if we're coming out of a hole and create a new empty segment
      if(hole) {
        segments.push({
          pathCoordinates: [],
          valueData: []
        });
        // As we have a valid value now, we are not in a "hole" anymore
        hole = false;
      }

      // Add to the segment pathCoordinates and valueData
      segments[segments.length - 1].pathCoordinates.push(pathCoordinates[i], pathCoordinates[i + 1]);
      segments[segments.length - 1].valueData.push(valueData[i / 2]);
    }
  }

  return segments;
};
}(this, Chartist));
  

    Chartist.Interpolation.none = function(options) {
  var defaultOptions = {
    fillHoles: false
  };
  options = Chartist.extend({}, defaultOptions, options);
  return function none(pathCoordinates, valueData) {
    var path = new Chartist.Svg.Path();
    var hole = true;

    for(var i = 0; i < pathCoordinates.length; i += 2) {
      var currX = pathCoordinates[i];
      var currY = pathCoordinates[i + 1];
      var currData = valueData[i / 2];

      if(Chartist.getMultiValue(currData.value) !== undefined) {

        if(hole) {
          path.move(currX, currY, false, currData);
        } else {
          path.line(currX, currY, false, currData);
        }

        hole = false;
      } else if(!options.fillHoles) {
        hole = true;
      }
    }

    return path;
  };
};
  

var chart = new Chartist.Line('.ct-chart', {
  labels: [1, 2, 3, 4, 5],
  series: [[1, 2, 8, 1, 7]]
}, {
  lineSmooth: Chartist.Interpolation.none({
    fillHoles: false
  })
});

    Chartist.Interpolation.simple = function(options) {
  var defaultOptions = {
    divisor: 2,
    fillHoles: false
  };
  options = Chartist.extend({}, defaultOptions, options);

  var d = 1 / Math.max(1, options.divisor);

  return function simple(pathCoordinates, valueData) {
    var path = new Chartist.Svg.Path();
    var prevX, prevY, prevData;

    for(var i = 0; i < pathCoordinates.length; i += 2) {
      var currX = pathCoordinates[i];
      var currY = pathCoordinates[i + 1];
      var length = (currX - prevX) * d;
      var currData = valueData[i / 2];

      if(currData.value !== undefined) {

        if(prevData === undefined) {
          path.move(currX, currY, false, currData);
        } else {
          path.curve(
            prevX + length,
            prevY,
            currX - length,
            currY,
            currX,
            currY,
            false,
            currData
          );
        }

        prevX = currX;
        prevY = currY;
        prevData = currData;
      } else if(!options.fillHoles) {
        prevX = currX = prevData = undefined;
      }
    }

    return path;
  };
};
  

var chart = new Chartist.Line('.ct-chart', {
  labels: [1, 2, 3, 4, 5],
  series: [[1, 2, 8, 1, 7]]
}, {
  lineSmooth: Chartist.Interpolation.simple({
    divisor: 2,
    fillHoles: false
  })
});

    Chartist.Interpolation.cardinal = function(options) {
  var defaultOptions = {
    tension: 1,
    fillHoles: false
  };

  options = Chartist.extend({}, defaultOptions, options);

  var t = Math.min(1, Math.max(0, options.tension)),
    c = 1 - t;

  return function cardinal(pathCoordinates, valueData) {
    // First we try to split the coordinates into segments
    // This is necessary to treat "holes" in line charts
    var segments = Chartist.splitIntoSegments(pathCoordinates, valueData, {
      fillHoles: options.fillHoles
    });

    if(!segments.length) {
      // If there were no segments return 'Chartist.Interpolation.none'
      return Chartist.Interpolation.none()([]);
    } else if(segments.length > 1) {
      // If the split resulted in more that one segment we need to interpolate each segment individually and join them
      // afterwards together into a single path.
        var paths = [];
      // For each segment we will recurse the cardinal function
      segments.forEach(function(segment) {
        paths.push(cardinal(segment.pathCoordinates, segment.valueData));
      });
      // Join the segment path data into a single path and return
      return Chartist.Svg.Path.join(paths);
    } else {
      // If there was only one segment we can proceed regularly by using pathCoordinates and valueData from the first
      // segment
      pathCoordinates = segments[0].pathCoordinates;
      valueData = segments[0].valueData;

      // If less than two points we need to fallback to no smoothing
      if(pathCoordinates.length <= 4) {
        return Chartist.Interpolation.none()(pathCoordinates, valueData);
      }

      var path = new Chartist.Svg.Path().move(pathCoordinates[0], pathCoordinates[1], false, valueData[0]),
        z;

      for (var i = 0, iLen = pathCoordinates.length; iLen - 2 * !z > i; i += 2) {
        var p = [
          {x: +pathCoordinates[i - 2], y: +pathCoordinates[i - 1]},
          {x: +pathCoordinates[i], y: +pathCoordinates[i + 1]},
          {x: +pathCoordinates[i + 2], y: +pathCoordinates[i + 3]},
          {x: +pathCoordinates[i + 4], y: +pathCoordinates[i + 5]}
        ];
        if (z) {
          if (!i) {
            p[0] = {x: +pathCoordinates[iLen - 2], y: +pathCoordinates[iLen - 1]};
          } else if (iLen - 4 === i) {
            p[3] = {x: +pathCoordinates[0], y: +pathCoordinates[1]};
          } else if (iLen - 2 === i) {
            p[2] = {x: +pathCoordinates[0], y: +pathCoordinates[1]};
            p[3] = {x: +pathCoordinates[2], y: +pathCoordinates[3]};
          }
        } else {
          if (iLen - 4 === i) {
            p[3] = p[2];
          } else if (!i) {
            p[0] = {x: +pathCoordinates[i], y: +pathCoordinates[i + 1]};
          }
        }

        path.curve(
          (t * (-p[0].x + 6 * p[1].x + p[2].x) / 6) + (c * p[2].x),
          (t * (-p[0].y + 6 * p[1].y + p[2].y) / 6) + (c * p[2].y),
          (t * (p[1].x + 6 * p[2].x - p[3].x) / 6) + (c * p[2].x),
          (t * (p[1].y + 6 * p[2].y - p[3].y) / 6) + (c * p[2].y),
          p[2].x,
          p[2].y,
          false,
          valueData[(i + 2) / 2]
        );
      }

      return path;
    }
  };
};
  

var chart = new Chartist.Line('.ct-chart', {
  labels: [1, 2, 3, 4, 5],
  series: [[1, 2, 8, 1, 7]]
}, {
  lineSmooth: Chartist.Interpolation.cardinal({
    tension: 1,
    fillHoles: false
  })
});

    Chartist.Interpolation.monotoneCubic = function(options) {
  var defaultOptions = {
    fillHoles: false
  };

  options = Chartist.extend({}, defaultOptions, options);

  return function monotoneCubic(pathCoordinates, valueData) {
    // First we try to split the coordinates into segments
    // This is necessary to treat "holes" in line charts
    var segments = Chartist.splitIntoSegments(pathCoordinates, valueData, {
      fillHoles: options.fillHoles,
      increasingX: true
    });

    if(!segments.length) {
      // If there were no segments return 'Chartist.Interpolation.none'
      return Chartist.Interpolation.none()([]);
    } else if(segments.length > 1) {
      // If the split resulted in more that one segment we need to interpolate each segment individually and join them
      // afterwards together into a single path.
        var paths = [];
      // For each segment we will recurse the monotoneCubic fn function
      segments.forEach(function(segment) {
        paths.push(monotoneCubic(segment.pathCoordinates, segment.valueData));
      });
      // Join the segment path data into a single path and return
      return Chartist.Svg.Path.join(paths);
    } else {
      // If there was only one segment we can proceed regularly by using pathCoordinates and valueData from the first
      // segment
      pathCoordinates = segments[0].pathCoordinates;
      valueData = segments[0].valueData;

      // If less than three points we need to fallback to no smoothing
      if(pathCoordinates.length <= 4) {
        return Chartist.Interpolation.none()(pathCoordinates, valueData);
      }

      var xs = [],
        ys = [],
        i,
        n = pathCoordinates.length / 2,
        ms = [],
        ds = [], dys = [], dxs = [],
        path;

      // Populate x and y coordinates into separate arrays, for readability

      for(i = 0; i < n; i++) {
        xs[i] = pathCoordinates[i * 2];
        ys[i] = pathCoordinates[i * 2 + 1];
      }

      // Calculate deltas and derivative

      for(i = 0; i < n - 1; i++) {
        dys[i] = ys[i + 1] - ys[i];
        dxs[i] = xs[i + 1] - xs[i];
        ds[i] = dys[i] / dxs[i];
      }

      // Determine desired slope (m) at each point using Fritsch-Carlson method
      // See: http://math.stackexchange.com/questions/45218/implementation-of-monotone-cubic-interpolation

      ms[0] = ds[0];
      ms[n - 1] = ds[n - 2];

      for(i = 1; i < n - 1; i++) {
        if(ds[i] === 0 || ds[i - 1] === 0 || (ds[i - 1] > 0) !== (ds[i] > 0)) {
          ms[i] = 0;
        } else {
          ms[i] = 3 * (dxs[i - 1] + dxs[i]) / (
            (2 * dxs[i] + dxs[i - 1]) / ds[i - 1] +
            (dxs[i] + 2 * dxs[i - 1]) / ds[i]);

          if(!isFinite(ms[i])) {
            ms[i] = 0;
          }
        }
      }

      // Now build a path from the slopes

      path = new Chartist.Svg.Path().move(xs[0], ys[0], false, valueData[0]);

      for(i = 0; i < n - 1; i++) {
        path.curve(
          // First control point
          xs[i] + dxs[i] / 3,
          ys[i] + ms[i] * dxs[i] / 3,
          // Second control point
          xs[i + 1] - dxs[i] / 3,
          ys[i + 1] - ms[i + 1] * dxs[i] / 3,
          // End point
          xs[i + 1],
          ys[i + 1],

          false,
          valueData[i + 1]
        );
      }

      return path;
    }
  };
};
  

var chart = new Chartist.Line('.ct-chart', {
  labels: [1, 2, 3, 4, 5],
  series: [[1, 2, 8, 1, 7]]
}, {
  lineSmooth: Chartist.Interpolation.monotoneCubic({
    fillHoles: false
  })
});

    Chartist.Interpolation.step = function(options) {
  var defaultOptions = {
    postpone: true,
    fillHoles: false
  };

  options = Chartist.extend({}, defaultOptions, options);

  return function step(pathCoordinates, valueData) {
    var path = new Chartist.Svg.Path();

    var prevX, prevY, prevData;

    for (var i = 0; i < pathCoordinates.length; i += 2) {
      var currX = pathCoordinates[i];
      var currY = pathCoordinates[i + 1];
      var currData = valueData[i / 2];

      // If the current point is also not a hole we can draw the step lines
      if(currData.value !== undefined) {
        if(prevData === undefined) {
          path.move(currX, currY, false, currData);
        } else {
          if(options.postpone) {
            // If postponed we should draw the step line with the value of the previous value
            path.line(currX, prevY, false, prevData);
          } else {
            // If not postponed we should draw the step line with the value of the current value
            path.line(prevX, currY, false, currData);
          }
          // Line to the actual point (this should only be a Y-Axis movement
          path.line(currX, currY, false, currData);
        }

        prevX = currX;
        prevY = currY;
        prevData = currData;
      } else if(!options.fillHoles) {
        prevX = prevY = prevData = undefined;
      }
    }

    return path;
  };
};

}(this, Chartist));
  

var chart = new Chartist.Line('.ct-chart', {
  labels: [1, 2, 3, 4, 5],
  series: [[1, 2, 8, 1, 7]]
}, {
  lineSmooth: Chartist.Interpolation.step({
    postpone: true,
    fillHoles: false
  })
});

    Chartist.Svg.isSupported = function(feature) {
  return document.implementation.hasFeature('http://www.w3.org/TR/SVG11/feature#' + feature, '1.1');
};

/**
 * This Object contains some standard easing cubic bezier curves. Then can be used with their name in the `Chartist.Svg.animate`. You can also extend the list and use your own name in the `animate` function. Click the show code button to see the available bezier functions.
 *
 * @memberof Chartist.Svg
 */
var easingCubicBeziers = {
  easeInSine: [0.47, 0, 0.745, 0.715],
  easeOutSine: [0.39, 0.575, 0.565, 1],
  easeInOutSine: [0.445, 0.05, 0.55, 0.95],
  easeInQuad: [0.55, 0.085, 0.68, 0.53],
  easeOutQuad: [0.25, 0.46, 0.45, 0.94],
  easeInOutQuad: [0.455, 0.03, 0.515, 0.955],
  easeInCubic: [0.55, 0.055, 0.675, 0.19],
  easeOutCubic: [0.215, 0.61, 0.355, 1],
  easeInOutCubic: [0.645, 0.045, 0.355, 1],
  easeInQuart: [0.895, 0.03, 0.685, 0.22],
  easeOutQuart: [0.165, 0.84, 0.44, 1],
  easeInOutQuart: [0.77, 0, 0.175, 1],
  easeInQuint: [0.755, 0.05, 0.855, 0.06],
  easeOutQuint: [0.23, 1, 0.32, 1],
  easeInOutQuint: [0.86, 0, 0.07, 1],
  easeInExpo: [0.95, 0.05, 0.795, 0.035],
  easeOutExpo: [0.19, 1, 0.22, 1],
  easeInOutExpo: [1, 0, 0, 1],
  easeInCirc: [0.6, 0.04, 0.98, 0.335],
  easeOutCirc: [0.075, 0.82, 0.165, 1],
  easeInOutCirc: [0.785, 0.135, 0.15, 0.86],
  easeInBack: [0.6, -0.28, 0.735, 0.045],
  easeOutBack: [0.175, 0.885, 0.32, 1.275],
  easeInOutBack: [0.68, -0.55, 0.265, 1.55]
};

Chartist.Svg.Easing = easingCubicBeziers;

/**
 * This helper class is to wrap multiple `Chartist.Svg` elements into a list where you can call the `Chartist.Svg` functions on all elements in the list with one call. This is helpful when you'd like to perform calls with `Chartist.Svg` on multiple elements.
 * An instance of this class is also returned by `Chartist.Svg.querySelectorAll`.
 *
 * @memberof Chartist.Svg
 * @param {Array<Node>|NodeList} nodeList An Array of SVG DOM nodes or a SVG DOM NodeList (as returned by document.querySelectorAll)
 * @constructor
 */
function SvgList(nodeList) {
  var list = this;

  this.svgElements = [];
  for(var i = 0; i < nodeList.length; i++) {
    this.svgElements.push(new Chartist.Svg(nodeList[i]));
  }

  // Add delegation methods for Chartist.Svg
  Object.keys(Chartist.Svg.prototype).filter(function(prototypeProperty) {
    return ['constructor',
        'parent',
        'querySelector',
        'querySelectorAll',
        'replace',
        'append',
        'classes',
        'height',
        'width'].indexOf(prototypeProperty) === -1;
  }).forEach(function(prototypeProperty) {
    list[prototypeProperty] = function() {
      var args = Array.prototype.slice.call(arguments, 0);
      list.svgElements.forEach(function(element) {
        Chartist.Svg.prototype[prototypeProperty].apply(element, args);
      });
      return list;
    };
  });
}

Chartist.Svg.List = Chartist.Class.extend({
  constructor: SvgList
});
}(this, Chartist));